This white paper demonstrates how Gupta's Client/Server System works.
Client/server computing has begun to move from the proof-of-concept stage to the implementation stage. This transition is the logical continuation of a move to exploit the price/performance benefits of PC LAN-based development.
Most successful businesses recognize information as a strategic asset and appropriate information technology as a competitive advantage. With nothing less at stake than their organizations' market competitiveness, information systems (IS) managers have been understandably cautious about embracing new application development and deployment models such as client/server.
IS managers see problems lurking behind the promises of greater productivity, easy-to-use graphical interfaces, shorter development cycles, and the ability for users to participate in the development process. How will development teams master new operating systems and new programming paradigms? How will they manage complex network configurations? How will they prevent users from wreaking havoc with corporate data? How will they effectively set large teams of developers to work solving complex application problems? Will undertaking client/server projects result in smooth-running systems to manage corporate information or create a black hole that swallows time, programming resources, and money?
An effective client/server development system must offer corporate development teams the reliability of a single source for tools, databases, connectivity, and, most importantly, for accountability: one place to go to solve a problem about the software portion of a client/server application. At the same time, the system must be open and flexible, able to perform to spec in today's complex, multi-vendor, multi-platform world. The system must address the enterprise integration issues crucial to mission-critical applications. It must enhance, not inhibit, developer productivity. It should be neither a retrofitted mainframe development system nor a pumped-up PC development system, but a system designed from the ground up for client/server development.
This white paper will demonstrate how Gupta's Client/Server System powers you beyond the startup stage to complete corporate-class client/server applications.
During the 1980s, increasing demand by end users for personal spreadsheets, personal and departmental database applications, and rapid reporting on personal data led to the widespread adoption of personal computers (PCs). At the same time, the gap widened between users' needs and the ability of centralized information systems (IS) and data processing (DP) departments to deliver on those needs. By the middle of the decade, so-called desktop PCs sat on the desks of millions of users, connected by sophisticated local area networks (LANs). Yet these computers remained separate from the mainline data processing activities of many organizations.
By the end of the decade, desktop machines grew in power and businesses began to view PCs as a strategic information platform. The question then became how corporate IS departments could leverage the power of desktop machines while integrating them with their organizations' central data processing functions. IS found its answer in client/server architecture, which takes advantage of the graphical presentation capabilities of desktop machines, the high performance of LANs, and the processing power of "downsized" server machines running operating systems such as NetWare, OS/2, and UNIX.
Today, corporate development organizations that once created COBOL programs to run on an IBM 3090 must serve users' information needs by creating programs that not only run on a PC LAN platform but exploit the advantages of that platform. These advantages include
Corporate database applications designed for the desktop must match all the capabilities of their mainframe counterparts -- such as security, data integrity, reliability, and performance -- while providing additional features that users not only expect, but demand. Users require
In response to the new requirements of client/server architecture, the model for application development is changing. The traditional model, sometimes called the waterfall model, was rigid and monolithic. The emerging model is flexible and iterative. In the traditional model, the IS organization oversaw distinct planning, analysis, design, and construction stages. System analysts conducted end-user interviews to assess business needs and system requirements, then handed control off to a development team. Developers then built the system, usually with minimal end-user interaction.
While the completeness and rigor of the waterfall model may promise better systems, it cannot accommodate modern business realities. Using the waterfall model, development progresses too slowly, and businesses that wish to remain competitive cannot afford to wait for working information systems. Furthermore, users now expect more of their systems. Without ongoing user involvement, systems tend to fall short of users' expectations.
To increase productivity and deliver information systems more quickly, IS managers have adopted alternative methodologies such as Rapid Application Development (RAD) and Joint Application Development (JAD). These new methods focus on iterative systems design and increased interaction between end users and developers, especially early in the life cycle. This reduces the lag between concept and prototype and hastens progress from planning to construction. A new generation of fourth-generation language (4GL), graphical, and client/server tools helps developers prototype and deliver highly functional applications in record time.
Although RAD and JAD offer viable solutions to many application development problems, they are futile without the correct tools for designing, rapid prototyping, coding, deploying, and managing systems. The challenge to vendors is to provide flexible, powerful and reliable development tools that will maximize the returns from RAD and JAD. Products such as Gupta's SQLWindows are ideally suited to RAD and JAD.
Toyota Supports Corporate Mission with Gupta Products
The 4,800 employees at Toyota's Camry manufacturing plant in Georgetown, Kentucky are so dedicated to the goals of customer support, quality control, and job improvement that the plant won the highly respected J.D. Power Golden Plant Award in 1993. These three goals make up a corporate mission that inspires the entire company -- including the 50-person information systems center.
Toyota's just-in-time (J.I.T.) parts ordering system was based on mainframe computer technology. When assembly line workers opened a box of parts, they sent a barcoded card to the ordering room, where the card was scanned and a parts order printed to trigger the next delivery. While the system performed ordering basics, it did not provide decision-support information to production staff and did not tie together the ordering rooms at different plant locations. Any new system developed by Toyota needed to be completely reliable, since any interruption of the parts ordering system interferes with the plant's operation.
Toyota adopted client/server technology from Gupta Corporation to update its Plant Floor System. Developed with SQLWindows, the system uses Gupta SQLBase and Gupta SQLNetwork for DB2, which gives client PCs access to mainframe data. Now, production office staff have access to real-time information about delivery schedules and timing, suppliers, part numbers, and orders. Using analytical information such as average hourly orders and fluctuations provided by the Plant Floor System, production staff can solve problems more quickly and anticipate trouble spots.
The system's client/server architecture connects computers in ordering rooms at multiple plant locations by a local area network (LAN), allowing company-wide sharing of ordering information.
Toyota selected Gupta's SQLWindows as its standard development environment because the 50-person IS center found the product flexible, easy to use, and virtually unlimited in its capabilities. More importantly, Gupta's tools allowed Toyota to uphold its plant-wide commitment to customer support, quality control, and continual job improvement. The plant has created 15 applications for the entire facility since adopting SQLWindows in June 1993, including the mission-critical Plant Floor System.
IS organizations that created large-scale systems always faced the challenges associated with organizing teams of programmers effectively and managing large amounts of data. Mainframe systems and tools were equipped for these tasks. Today, developers who want to move beyond the pilot stage to get client/server applications done need mainframe-class tools optimized for the PC LAN environment.
Early users of client/server tools were impressed by how easily they could build GUIs and program database interaction. For small-scale pilot projects, ease of use was sufficient. As developers began working on larger applications, however, they needed better support for large-scale development. They identified features commonly available on minicomputer and mainframe platforms (such as repository support and source code control) as essential for client/server success.
Unfortunately, few desktop tools offer robust features supporting large-scale application development while preserving the benefits of the client/server environment. Simply duplicating traditional mainframe programming benefits in a client/server environment won't work. Users expect simple graphical interfaces and transparent connectivity to corporate data. To deliver on end-user expectations, IS personnel must collaborate in new ways. Support for team programming, once the concern only of groups of mainframe programmers, is now essential to client/server developers.
The complexities of GUI applications require a fresh development approach a 4GL GUI application also is likely to have more components than a traditional, non-GUI application. The additional components might include bit maps, online help libraries, reports, and class libraries. Often, multiple versions of each component exist during development, making it more difficult to manage the configuration. Developers may specialize in development of front-end or back-end code or reusable components. The development system must allow easy integration and management of many diverse program components.
The TeamWindows component of Gupta's SQLWindows combines the security and power of mainframe systems with the flexibility of today's graphical tools to make your development team more productive with superior project management. Team programming facilities in SQLWindows are tightly integrated with the Gupta Open repository. The Repository provides a structure for assembling reusable application components and supports management of staff resources, tracking activities through different stages of the application life cycle, promoting interaction between team members, and management reporting of project status.
Today's IS organizations often juggle many projects to keep up with application demand. SQLWindows, through TeamWindows, provides a complete, three-dimensional project management model. Project administrators can
The intersection elements of this three-dimensional model accurately specify which team member can work on which project stage and in what capacity, giving the project full control over how to allocate resources among projects.
By allowing tracking of multiple projects in the repository, SQLWindows allows you to share components such as data definitions or code modules between projects. For example, you might want to use the same report module for an annual revenue report across multiple projects. Source code control facilities (described later) ensure that one developer does not overwrite the work of another. In addition, most projects use components of many types. For example, a project may contain SQLWindows screens, bitmap files and documentation libraries. The TeamWindows component of SQLWindows allows easy tracking of these diverse module types.
The TeamWindows component of SQLWindows provides check-in/check-out facilities that assure you only one programmer at a time can modify a piece of code. A programmer must check out a module from the repository before working on it. Other programmers have only read-only access to the module until it is checked back in. TeamWindows tracks all check-in/check-out activities and lets project managers monitor application progress. As programmers check modules back into the repository, TeamWindows automatically increments the version number using any numbering scheme you wish.
Members of a project team often play different roles. To help model the team structure in the Gupta Open Repository, the four levels of TeamWindows users can have different levels of responsibility and privilege. A project administrator has the highest level of privilege and can oversee multiple projects. The next highest level of privilege belongs to the project manager, who has full control over a single project and can grant a developer access to modules in the development stage while restricting testers' access to modules in the testing stage.
Improved formal communication is a valuable benefit of project management facilities. Over time, this builds up into valuable project documentation. Each time a module is checked out of the repository for development, a modification log entry is recorded. This results in valuable historical information that benefits team members doing shared development or new team members who take over a project subset. In addition, a project log allows tracking of ongoing development work by making entries into a log sheet accessible to all team members. A project log is valuable for tracking information such as bugs that need fixing before production or enhancement requests for the next version.
New development methodologies such as RAD and JAD are eroding the walls that traditionally separated members of the development team. Users become an increasingly important part of the development picture.
Most significantly, end users now enter the development cycle earlier. Earlier involvement makes it more likely that the systems will satisfy end users. Also, computer-savvy end users are more likely to fulfill their simple information needs by building applications themselves. Many users have begun to experiment with easy-to-use graphical query and reporting tools.
Historically, IS managers have been reluctant to give end users more ownership of IS tasks. But involvement of end users in application development is both desirable and inevitable, for several reasons:
IS organizations need to integrate the simple applications end users create into the more sophisticated applications built by IS professionals. The architecture of today's development systems must maximize the benefits of early user involvement.
The use of 4GL GUI tools represents a significant change in the software development infrastructure and culture. The modern GUI application enables so-called "event-driven" applications, in which users can initiate operations in any order by selecting objects on the screen. With graphical applications, the developer can make fewer assumptions about end-user behavior. The developer and end user must spend more time together reviewing functionality.
Gupta tools encourage and support interaction between end users and developers. Quest, Gupta's end-user data management tool, allows users to build ad hoc queries and reports. Because Quest shares a graphical query engine with SQLWindows, Gupta's graphical development environment, SQLWindows developers can integrate user-built Quest objects. Novice programmers can build database interfaces without SQL expertise and developers can integrate and reuse Quest objects in SQLWindows applications.
Today's trend toward user participation in development means additional review and deployment cycles. Using the information stored in the Gupta Open Repository, the TeamWindows component of SQLWindows tracks all changes to your application and database and warns you if changes will affect other screens in the application -- or even other applications. TeamWindows' impact analysis facility helps you see the potential effects of changes you make in response to user feedback.
Increased user involvement also means more changes through an application's life cycle. SQLWindows helps you maintain applications over time by providing life-cycle support for testing applications and managing changes -- including changes to the database or to delivered applications.
Typically, the various components of a project are in various stages of completion. While some modules are in development, others might be in testing, and yet others might be ready for sharing by developers who want to reuse functionality from a colleague's module. The project manager can phase into production all components that have completed testing. TeamWindows allows you to designate the stage of the life cycle to which each component belongs. As developers complete work on each component within that stage, a developer can promote it to the next stage. For example, upon completion of development, a developer can promote a screen module into the test stage, where quality assurance staff can access it.
Eager to get started developing client/server applications, many IS organizations adopted tools because they were easy to learn and use. As they begin developing large-scale applications, however, these IS organizations often encounter limitations imposed by the tools they have chosen. Issues such as project management, version control, security, CASE integration, code reusability, standards, interoperability, and database performance all assume greater importance to the development organization and, ultimately, to the business. Ease-of-use cannot come at the expense of functionality and the ability to create and sustain complex applications that address large-scale information needs.
The components of Gupta's Client/Server System -- SQLWindows, Quest, SQLBase, and SQLNetwork -- each provide robust features capable of taking developers beyond the pilot stage to development and deployment of large-scale systems.
Developing reliable, high-performance, mission critical applications requires highly integrated tools that support development from the design phase through long-term maintenance. An open, multiuser repository that can manage and integrate the diverse needs and content of complex development efforts is central to the successful completion of large-scale development projects. This section discusses the requirements for a good repository. The following section discusses how Gupta's Open Repository serves as the centerpiece for a rigorous, productive approach to development and illustrates why repository-based development is the best model for client/server applications.
Some vendors incorrectly call a "data dictionary" a "repository." A data dictionary manages database definitions and some extended attribute information such as edit styles or validation rules. It does not provide the many other features and benefits of a repository -- version control, dependency management, standards management, impact analysis, and project management. The data dictionary is primarily a passive store of information, while the repository is an active management tool. The data dictionary and the production database must be stored together. However, the repository is securely insulated from the production environment. This is important because it is very unsafe to give developers privileges on a production environment. A data dictionary is valuable, but a repository is far more secure and is central to team programming.
A good repository implementation should
The overall benefits of a repository far outweigh the costs of defining, administering, and using it. The repository can
The team programming facilities enabled by the Gupta Open Repository allow teams of developers to work together and easily manage multiple project components through an application's life cycle. These powerful facilities allow developers to complete and maintain complex, mission-critical client/server applications.
As discussed in the previous section, an open repository is a necessary component of successful client/server development for many reasons. One of the most significant factors is the ability of teams of programmers to work together effectively. As the size of the development team and project grows, so does the importance a repository. Attempting team programming without a repository is like operating a database without a data dictionary to manage its contents -- small systems will be safe, but as they grow they become unmanageable.
Through its TeamWindows feature set, Gupta's SQLWindows provides tools that make teamwork effective without compromising individual creativity. Built around the Gupta Open Repository, a central store of all project-related information, TeamWindows helps SQLWindows developers build applications more quickly. The Gupta Open Repository enables storage, management, and sharing of all objects associated with the information system.
The broad range of tools required for client/server development means no single vendor can deliver all the necessary facilities in an innovative and timely manner. To build an open and complete solution, a vendor must judiciously mix core technology with interfaces to other best-of-breed products. This philosophy underlies Gupta's approach.
However, certain core facilities must be available before best-of-breed synthesis can occur. The primary prerequisite is a central warehouse for all project related information -- the repository. Without a true repository, best of breed integration will appear to be a patchwork rather than a seamless solution. The repository must provide core services such as project management, configuration management, and project security. Interfaces to best-of-breed products can add services such as business modeling, quality assurance, and electronic software distribution.
The Gupta Open Repository is extensible and can store all information associated with the development of a complete client/server information system. It is open because it can store not only modules created with Gupta tools, but also objects created with other tools. The Gupta Open Repository manages the following types of information:
Gupta believes that as customers attempt to build even larger client/server systems, the role of a repository in the development process will assume greater importance. Consequently, significant efforts are underway to further enhance the Gupta Open Repository.
The reality of team programming means multiple programmers working on multiple versions of program components simultaneously. The repository's project management model should incorporate security through such facilities as assignment of privilege levels. The repository administrator should be able to assign privilege levels to all repository users and specify access controls to all repository objects. Without these facilities, a repository is analogous to a multiuser operating system without login identification or file security controls.
A repository also must provide version control for all project information. Together, security features and version control protect project modules against unauthorized or accidental modifications or deletion.
Two major problems facing IS staff today are poor programmer productivity and the difficulty of application maintenance. Object-oriented programming (OOP) techniques, supported by a robust and open repository, can alleviate these tough development problems.
With OOP, programmers combine code and data into logical objects that hide complexity and are simple to reuse, integrate, and maintain. For example, a programmer can create -- and instantly save as a class -- a graphical object such as a push button that performs a database update. Later, the same programmer or a different team member can reuse existing code and save time by creating new objects based on that class. Reusing code saves time and money and simplifies maintenance, increasing team productivity.
Several facilities in SQLWindows help team members share and reuse application components. Some of these facilities -- such as window classes, functional classes, and templates -- are OOP features. Other facilities, such as starter files and includable libraries, assume no knowledge of OOP. The Gupta Open Repository allows effective sharing of objects. For example, developers can reuse both graphical and functional (non-graphical) objects by making them into general purpose and reusable classes, which team members can share through the Gupta Open Repository.
OOP features also help promote standards. For example, in a company with many divisions, a central IS group might have responsibility for establishing standards and building standard components for functionality common throughout the company. When departmental IS teams reuse application components built by the central IS group built, their new applications automatically conform to the centralized standards. The object-oriented components built by the central IS staff can be stored in the multiuser Gupta Open Repository for sharing by team members.
A significant challenge for developers of today's client/server systems is the integration of heterogeneous computers, operating systems, communications standards, and databases. In organizations with an existing mainframe infrastructure, legacy applications must continue to operate effectively, and interoperate with newer graphical systems. Developers also face the challenges posed by physically distributed data and "nomadic" users on mobile systems.
Gupta's approach to client/server development addresses all these issues.
A client/server development system must provide not only superior performance for the future, but a bridge to legacy data. IS managers today are responsible for continuing the return on investments their predecessors made in hardware, database technology, and development systems. Any new system they adopt must provide the tools necessary to use existing or legacy data. Gupta's Tools Integration for the Enterprise (TIE) strategy (discussed later) provides for the easy integration of legacy data.
Gupta Products Help Tandy Corporation Executives Get Timely Sales Results
Tandy Corporation is an electronics retailer with outlets across the U.S. More than 4,800 Radio Shack stores, 39 Computer City stores, and more than 200 outlets for Tandy Name Brands generate between 800 and 1,200 database transactions per day.
In the past, Tandy's top executive decision makers received hand-delivered paper printouts reporting on the previous day's sales information each morning at about nine. These reports ran overnight as batch jobs on the company's mainframe system. Executives wanted earlier access to daily sales results and a way to manage report archives -- and they wanted to be able to get this information while traveling.
To provide executives with earlier access to sales information, Tandy's Information Services (IS) department developed the LOOK! Report Management System. Now, instead of printing reports created on the company's IBM 3090 plug-compatible mainframe, Tandy connects to the IBM DB2 database using Gupta's SQLGateway and SQLHost connectivity products, captures the reports, and stores them in a Gupta SQLBase database. Nearly 150 executives now have access to thousands of reports between 1 a.m. and 6 a.m.
The LOOK! High Security System is a component of the LOOK! Report Management System written in Gupta's SQLWindows that allows control over who sees which reports. The LOOK! Usage Reports application, a companion SQLWindows application, analyzes the performance and usage of the LOOK! Report Management System. The LOOK! Usage Reports application helps top executives decide, based on frequency of viewing, who needs to continue seeing certain information.
The LOOK! Report Management System is one of the most successful applications ever produced by Tandy's IS organization. The extra hours of availability let executives get a jump on making decisions. The ability to monitor who views information gives them tighter control over sensitive data. And, when they're on the road, they simply dial in to the local area network (LAN) and enjoy the same report access as if they were in their offices.
End-user needs for information are varied and often unpredictable. For example, during a single day an information worker in the retail industry might perform some data entry, sales reporting, and spreadsheet-based profit analysis. The worker might then electronically mail a word processed document with attached business graphics. To navigate this series of tasks smoothly, applications need to work together easily without requiring effort or technical prowess on the part of the end user.
Today, powerful facilities enable application transparency. Mechanisms such as Microsoft's Dynamic Data Exchange (DDE) and Object Linking and Embedding (OLE) and popular interfaces such as Vendor-Independent Messaging (VIM) and Messaging Application Programming Interface (MAPI), enable such interplay. It is unlikely that a single IS developer will build and integrate all the components of an end-user system. Team programming, as supported in Gupta's SQLWindows, becomes essential to achieving application transparency.
Microsoft Windows has become a standard for development of graphical client applications. Structured Query Language (SQL), is the industry standard data access and manipulation language for relational databases. Gupta's Client/Server System supports both these standards.
Connectivity is as important to the success of large-scale client/server applications as support for industry standards. Since the choice of a database is likely to be a strategic business decision, the development environment must provide easy connectivity to a wide variety of databases, allowing businesses a wide choice of databases and divorcing the choice of a development environment from the choice of a database. Gupta's SQLNetwork family of connectivity products provides connectivity to every major SQL database.
The Gupta Client/Server System is open and fully supports access to other development and deployment tools using a strategy called Tools Integration for the Enterprise (TIE). The open TIE strategy allows SQLWindows applications to fully cooperate with other best-of-breed products such as CASE tools, graphical testing tools, and transaction processing monitors. Gupta's TIE architecture provides a blueprint for the primary entry points available to third-party developers SQLWindows system.
Following the announcement of the TIE strategy in 1993, Gupta announced its CASE Interchange Architecture, which allows an upper-CASE tool user to export information to the TeamWindows component of the SQLWindows system. Conversely, a TeamWindows user may import this same information directly from an upper-CASE tool. In this scenario, details about the application database schema are imported directly from the upper-CASE tool into the Gupta Open Repository, rather than from the application database itself. This provides seamless integration from the modeling side to the application development side of the design process.
Early in 1994, Gupta announced its intention to build direct links between SQLWindows and Novell's Tuxedo system. Tuxedo, a UNIX-based network service that allows transactions on a network to be invoked, tracked, and monitored, belongs to a class of products known as transaction monitors. This integration enables SQLWindows developers to gain the benefits of a transaction processor like Tuxedo, including performance gains, high availability of services, load balancing, and data-dependent routing of service requests.
Gupta continues to actively pursue relationships with providers of external services for integration through the TIE architecture.
Developers need tools that allow them to support applications through the application life cycle. The ability to use computer-aided software engineering (CASE) tools to design databases and applications is a key element in the success of large-scale client/server applications, and a repository is key to providing this capability.
The Gupta Open Repository provides an interface between the SQLWindows development environment and popular CASE environments (such as Popkin Systems Architect and LBMS Systems Engineer). Thus, in the application construction stage, developers can make full use of analysis and design information captured with CASE products in the modeling stage. This results in more correct applications, delivered sooner. The CASE tools that interface with Gupta products can automatically generate a schema for the database systems supported, including Gupta's SQLBase server. This schema can then be imported into the Gupta Open Repository and effectively managed.
The day when IS organizations could rely on a single source for hardware, software, and tools is long gone. Today, many different vendors supply various components of a business's information management solution. Still, organizations can benefit from reducing the number of vendors with whom they must interact.
Gupta supplies a large piece of the information systems solution -- database, end user and developer tools, and connectivity -- allowing organizations to meet many needs at once with an integrated solution while dealing with a single vendor. The Gupta Client/Server System includes the SQLBase database server, SQLNetwork connectivity tools, the SQLWindows development environment, and Quest end-user data access tools.
At the same time, Gupta's tools and databases are open so they can work with existing data and industry-standard technology. Businesses can choose to implement all or part of the Gupta Client/Server System in a way that best serves their needs.
Database performance can become a make-or-break issue as developers move from small pilot client/server systems to large production systems. Speed and capacity can spell the difference between an application accepted by users and management and one that fails to deliver the required functionality. When organizations downsize, PC and LAN-based applications often must handle hundreds of simultaneous users, high numbers of transactions per second, and databases up to many gigabytes in size.
Organizations that choose to adopt Gupta's SQLBase server as the database platform for client/server applications benefit from a number of performance-related features. Enhancements planned for future versions of SQLBase will improve performance and simplicity of use, and provide additional features for sophisticated database management and scalability.
SQLBase's High Performance Keeps AdTrack on Track
Many of us feel buried in newsprint after a few weeks' worth of daily papers stack up. AdTrack, Inc., a newspaper monitoring service based in Jacksonville, Florida, takes delivery on 4,800 newspapers a month. "Dealing with that many physical papers is one of the biggest problems we face," says Howard Arner, vice president of computer operations for AdTrack. The accumulation of newsprint is just one part of the challenge. Managing the information gleaned from those papers is a tough job as well. For that, AdTrack relies on Gupta's SQLBase server and several rules-based programs written in Prolog.
AdTrack collects newspaper advertising information, which it reports to the advertising industry. The company currently monitors more than 300 publications across the United States. AdTrack's clients -- radio stations, television stations and cable systems, local broadcast associations, outdoor advertising companies, newspapers, a direct mail company, and a national research company -- want to know who is advertising in what markets and how much they're spending.
Managing information like manufactured goods
To gather the necessary data, AdTrack has set up what amounts to an information manufacturing operation. Each of the 4,800 papers arrives at a receiving area, where it's barcoded. With the stroke of a barcode reading wand, the barcode number enters the system, and process of scrutiny, measurement, and analysis begins.
AdTrack operators sit down with a paper, a column ruler, and a red grease pencil. They measure each advertisement in newspaper column inches and write the number on the page. (Arner says they considered automating this part of the process but found the cost exorbitant.) Operators then enter data at their workstations. For each advertisement, they fill in a screen that includes information such as the advertiser's name, inch measurement of the ad, number of colors, event associated with the ad (for example, grand opening or going out of business), page number, and section. When a screen of information is complete, the operator presses F9 to update the database.
A single SQLBase database
It's what goes on behind the scenes that's most impressive. All the data goes into a single SQLBase database, running on a 486 PC-compatible 66 MHz EISA machine. For storage, Arner users 6 GB of RAID 5 storage. A sophisticated validation program, written in Prolog, checks each entry against 190,000 existing advertisers. Validation takes less than 1/20th of a second -- such a short time that operators notice no difference between validated and non-validated fields. The actual posting of a record takes less than a tenth of a second. Response time remains quick even when all 12 operators are working at once. "The system is completely tuned for Gupta SQLBase," Arner says. "That's how we get such unbelievable performance."
Arner realized additional performance gains by taking advantage of the database partitioning features available in Gupta's SQLBase to distribute the data on the RAID array. "Initially, we didn't use these features," he says. "Now that we have, performance has improved by a factor of ten."
Performance and productivity gains
The performance gains were welcome at AdTrack, where, before adopting Gupta's SQLBase, the company attempted to manage their information using Advanced Revelation from Revelation Technologies. "For three to five days at the end of each month, operators had to run cleanup programs on the entries they made that month. Now we do all of that validation online, in real time." By implementing the Gupta system, AdTrack drastically cut turnaround time for its reports to clients.
The performance gains led to productivity gains and cost savings. AdTrack reduced data entry personnel from 30 to 17 and saved 18.5 percent on its remaining payroll. (The company is now able to pay its operators more.) With a production increase of 211 percent, the company increased its workload by 15 percent.
New markets opened
The system has done more than allow AdTrack to provide better and faster service to existing customers. With the ability to process information more quickly and accurately, the company is considering entering new markets such as direct mail monitoring. "Before the Gupta system," Arner says, "We couldn't do things like run a report for K-Mart that told them how much department store advertising there was in the Dallas and Houston markets between January 1 and January 31. Now we can. It's allowed us to take on national clients."
Gupta's SQLBase server, introduced in 1987, was the first SQL relational database server for PCs. It is known today as a fast, small, easy to use, and fully functional SQL database server optimized for the client/server environment. Designed from the ground up to support PC client/server applications, SQLBase is scalable from the laptop to the LAN server. This scalability means that as PC database applications grow in size, scope, and complexity, SQLBase keeps pace. It's easy to move an application designed for a single PC to a department server as a business grows.
IS managers who choose SQLBase as their database and SQLWindows as their development platform can realize the benefits of an integrated system. For example, SQLBase is one of the few LAN-based databases to address the issue of concurrency control, which it does in conjunction with SQLWindows.
Intuitive, easy-to-learn tools won't help developers create client/server applications if they hit barriers midway through a project. Gupta SQLWindows provides a complete system for starting -- and finishing -- powerful multiuser applications.
SQLWindows' Application Designer is a visual application design environment that allows developers to add and modify objects, which can incorporate images, sound, and video in addition to common data types. The Application Outliner, unique to SQLWindows, provides a complete view of application components in the form of a collapsible outline. When developers add or modify objects in the Application Designer window, SQLWindows generates code and adds it to the Application Outliner automatically. The outline gives developers a convenient way to navigate through large applications and eases application maintenance and enhancement.
SQLWindows Application Language (SAL) is a full-featured 4GL for programming custom application actions and object methods. It provides unlimited application control and extendibility with 500 SQLWindows and Microsoft Windows functions, plus the ability to create and share new functions. SAL supports any back-end data type, supports variables and arrays, and provides complete control flow. It can be integrated with C, C++, and COBOL code.
Object oriented programming (OOP) techniques can make development teams more productive and applications easier to maintain -- but only if OOP tools are accessible and easy to use. SQLWindows offers a complete implementation of OOP in a visual environment, integrated with a sophisticated database application language. Since SQLWindows' object orientation is optional, developers can get acquainted with OOP gradually. SQLWindows also supports Visual Basic Custom Controls (VBXs) to produce richer applications, and lets you save and reuse an entire window with new Window Class features.
SQLWindows 4.1 includes full business graphics support with the Quest Graphing Tool. Take advantage of a wide range of business graphs and charts, including line, bar, and pie charts, and even specialized charts such as high-low-close and log-lin. The Quest Graphing Tool creates graphs automatically and lets you view graphs on screen or print them as part of a report.
Users need the power to access corporate data easily, but easy data access is only half the story. IS organizations need a system to securely manage both data and access across the enterprise. Gupta's Quest, a client/server data management tool for end-users, delivers both.
Quest provides first-rate data access and reporting capabilities that make users more productive, whether they're novices or SQL-literate pros. The Quest environment consists of a Windows-standard interface and the Quest Activity Bar. Managers may customize the workspace by installing only some Quest Activities so that database access privileges match each user's skill level.
For users who don't need to create forms or create a database, Gupta's Quest Reporter provides the same powerful query and reporting capabilities as Quest without the advanced features for read-and-write database access, form generation, and catalog browsing. Quest Reporter is available separately.
IS staff can limit access to corporate data by choosing which Quest activities to install for particular users. Quest's form runtime module also lets you control database access by allowing users to run either updatable or non-updatable Quest forms. For greater security, IS can install both the Quest Table Activity and the Quest Catalog Activity with write privileges for local databases and read-only privileges for networked enterprise databases.
The choice of a database technology is usually based on how well a particular database server fulfills business requirements. Gupta offers plenty of choices for connecting SQLWindows client applications with data sources, all of which let you take advantage of the important benefits of the particular server. Gupta's SQLNetwork family of products -- comprising SQLGateways, SQLRouters, and connectivity that conforms to ODBC standards -- connects Gupta client applications to a variety of data sources, including Ingres, Informix, AS/400, Oracle, SQL Server, Database Manager (and DB2/2), and DB2, as well as desktop data sources such as Paradox, dBASE, and Access.
Gupta desktop tools have all been developed with an application programming interface called SQL/API, which is available to programmers to use in their own database applications. Gupta offers SQLHost/ Application Services, a tool for mainframe developers to write custom server applications under CICS.
Gupta SQLWindows can manage a wide range of SQL databases, including Gupta's popular SQLBase Server, via Gupta's SQLNetwork family of connectivity products. In addition to providing high-performance gateways to leading databases, Gupta is committed to providing support for industry standards such as Microsoft's Open Database Connectivity (ODBC) and IBM's Distributed Relational Database Architecture (DRDA).
Developers want to give end users a consistent interface to any network database they access -- without sacrificing access to the database's unique capabilities. SQLNetwork products provide a consistent API for client data requests to a wide variety of DBMSs.
Ending the Paper Chase
Gupta SQLBase and SQLWindows bring mainframe accounting into the 1990s
Like many individuals in large organizations who rely on mainframes for information management, the State of Delaware's financial and purchasing professionals shuffled a lot of paper and suffered without access to current financial information. The five levels of approval needed for purchasing and contract transactions meant managers and employees passed lots of paper back and forth. When a manager signed a service contract, the mainframe accounting system could take up to six weeks to reflect the change. In the meantime, the manager was forced to make decisions based on out-of-date data involving sums of as much as half a million dollars.
Access to legacy data
In 1991, the State of Delaware contracted with Public Systems Incorporated (PSI) of Wilmington, Delaware to build a computer system that solved these problems. PSI built the Operations Management System (OMS), which is currently installed at four sites statewide. OMS is actually a front end to the state's accounting system, which runs in Adabas on an IBM mainframe. The largest installation, at the Delaware Division of Public Health, has 105 users. "The system gives managers information they've never had before,"says Reese Robinson, senior consultant and managing partner of PSI.
Keeping data synchronized
Because OMS is only an interface to the mainframe accounting system, Robinson had to ensure that transactions entered in OMS remained in sync with the actual accounting system. PSI created an application in Natural, a 4GL (Fourth Generation Language) from Software AG. The SQLWindows application (OMS) passes a file of all approved transactions to the Natural application. Each night, the Natural application uploads the transaction information to the mainframe accounting system, which process it as a batch job like any other. The value, says Robinson, lies in the reconciliation process. After the transactions have cleared the mainframe, the Natural application passes information back to OMS, which highlights any discrepancies in cleared transactions. Users can then decide how to handle the differences.
Doing away with paper
In creating OMS, Robinson's development team faced several technical challenges, one of which was the state of Delaware's requirement that the electronic forms mimic existing paper forms. At the same time, the state required that the system do away with the paper approval process.
Using a combination of Borland C++ and the DDE (Dynamic Data Exchange) capabilities of SQLWindows, Gupta Corporation's client/server application development tool, PSI created on-screen forms that looked exactly like the existing hard copy documents.
To meet eliminate the paper approval process, PSI designed a workflow module using SQLWindows that routes forms from one approval level to the next. The workflow module uses a SQLBase database containing organizational intelligence about all individuals using the system. Based on a user's job description, responsibilities, and authority, the workflow module selects from the SQLBase database only those documents the user needs to see. When one person completes his or her part of a form, the system automatically makes it available to the next person who needs to see it. This process continues until the form receives final approval. To users, who simply complete necessary parts of documents appearing on their work lists, the system looks like an automatic electronic routing system. Eventually, PSI will add scanning capabilities to allow electronic transmission of signatures.
A long life for OMS
"We essentially re-engineered the State of Delaware's financial management process," says Robinson. "We took away their paper and their data entry clerks. What we ended up with is point-of-origination data entry."
OMS has a long life ahead of it, according to Robinson. The State of Delaware is eager to add modules for human resources, payroll, and budgeting that will afford the same quick access to data, ad hoc reporting, and workflow management in these areas.
As client/server projects move from pilot to production, IS organizations need a robust development environment that supports team programming and user involvement while maintaining enterprise-wide security and preserving investment in legacy data.
Gupta's Client/Server System combines mainframe-class robustness with the ease of graphical tools to provide a solution you can depend on. Gupta's SQLWindows application development environment incorporates team programming support with the Gupta Open Repository. Gupta's Quest and Quest Reporter provide easy SQL data management and access for end users, and integrate with SQLWindows applications. Gupta's SQLBase is a fast, efficient database server, scalable from subnotebooks to LAN servers and also available as a single-user engine. Gupta's SQLNetwork family of connectivity products provide access to a wide range of database servers, including Gupta's own SQLBase.
Gupta delivers everything you need to start client/server projects
today and get them done right.